home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Programming / Python1.4_Source / Modules / rotormodule.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-24  |  20.0 KB  |  816 lines
  1. /***********************************************************
  2. Copyright 1994 by Lance Ellinghouse,
  3. Cathedral City, California Republic, United States of America.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the name of Lance Ellinghouse
  12. not be used in advertising or publicity pertaining to distribution 
  13. of the software without specific, written prior permission.
  14.  
  15. LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE BE LIABLE FOR ANY SPECIAL, 
  18. INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING 
  19. FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, 
  20. NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION 
  21. WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  
  23. ******************************************************************/
  24.  
  25. /* This creates an encryption and decryption engine I am calling
  26.    a rotor due to the original design was a harware rotor with
  27.    contacts used in Germany during WWII.
  28.  
  29. Rotor Module:
  30.  
  31. -  rotor.newrotor('key') -> rotorobject  (default of 6 rotors)
  32. -  rotor.newrotor('key', num_rotors) -> rotorobject
  33.  
  34. Rotor Objects:
  35.  
  36. -  ro.setkey('string') -> None (resets the key as defined in newrotor().
  37. -  ro.encrypt('string') -> encrypted string
  38. -  ro.decrypt('encrypted string') -> unencrypted string
  39.  
  40. -  ro.encryptmore('string') -> encrypted string
  41. -  ro.decryptmore('encrypted string') -> unencrypted string
  42.  
  43. NOTE: the {en,de}cryptmore() methods use the setup that was
  44.       established via the {en,de}crypt calls. They will NOT
  45.       re-initalize the rotors unless: 1) They have not been
  46.       initalized with {en,de}crypt since the last setkey() call;
  47.       2) {en,de}crypt has not been called for this rotor yet.
  48.  
  49. NOTE: you MUST use the SAME key in rotor.newrotor()
  50.       if you wish to decrypt an encrypted string.
  51.       Also, the encrypted string is NOT 0-127 ASCII. 
  52.       It is considered BINARY data.
  53.  
  54. */
  55.  
  56. /* Rotor objects */
  57.  
  58. #include "Python.h"
  59.  
  60. #include "mymath.h"
  61.  
  62. #define TRUE    1
  63. #define FALSE    0
  64.  
  65. typedef struct {
  66.     PyObject_HEAD
  67.     int seed[3];
  68.         short key[5];
  69.     int  isinited;
  70.     int  size;
  71.     int  size_mask;
  72.         int  rotors;
  73.     unsigned char *e_rotor; /* [num_rotors][size] */
  74.     unsigned char *d_rotor; /* [num_rotors][size] */
  75.     unsigned char *positions; /* [num_rotors] */
  76.     unsigned char *advances; /* [num_rotors] */
  77. } PyRotorObject;
  78.  
  79. #include "protos/rotormodule_protos.h"
  80.  
  81. staticforward PyTypeObject PyRotor_Type;
  82.  
  83. #define PyRotor_Check(v)        ((v)->ob_type == &PyRotor_Type)
  84.  
  85. /*
  86.     This defines the necessary routines to manage rotor objects
  87. */
  88.  
  89. static void set_seed( r )
  90. PyRotorObject *r;
  91. {
  92.     r->seed[0] = r->key[0];
  93.     r->seed[1] = r->key[1];
  94.     r->seed[2] = r->key[2];
  95.     r->isinited = FALSE;
  96. }
  97.     
  98. /* Return the next random number in the range [0.0 .. 1.0) */
  99. static float r_random( r )
  100. PyRotorObject *r;
  101. {
  102.     int x, y, z;
  103.     float val, term;
  104.  
  105.     x = r->seed[0];
  106.     y = r->seed[1];
  107.     z = r->seed[2];
  108.  
  109.     x = 171 * (x % 177) - 2 * (x/177);
  110.     y = 172 * (y % 176) - 35 * (y/176);
  111.     z = 170 * (z % 178) - 63 * (z/178);
  112.     
  113.     if (x < 0) x = x + 30269;
  114.     if (y < 0) y = y + 30307;
  115.     if (z < 0) z = z + 30323;
  116.     
  117.     r->seed[0] = x;
  118.     r->seed[1] = y;
  119.     r->seed[2] = z;
  120.  
  121.     term = (float)(
  122.             (((float)x)/(float)30269.0) + 
  123.             (((float)y)/(float)30307.0) + 
  124.             (((float)z)/(float)30323.0)
  125.             );
  126.     val = term - (float)floor((double)term);
  127.  
  128.     if (val >= 1.0) val = 0.0;
  129.  
  130.     return val;
  131. }
  132.  
  133. static short r_rand(r,s)
  134. PyRotorObject *r;
  135. short s;
  136. {
  137.     /*short tmp = (short)((int)(r_random(r) * (float)32768.0) % 32768);*/
  138.     short tmp = (short)((short)(r_random(r) * (float)s) % s);
  139.     return tmp;
  140. }
  141.  
  142. static void set_key(r, key)
  143. PyRotorObject *r;
  144. char *key;
  145. {
  146. #ifdef BUGGY_CODE_BW_COMPAT
  147.     /* See comments below */
  148.     int k1=995, k2=576, k3=767, k4=671, k5=463;
  149. #else
  150.     unsigned long k1=995, k2=576, k3=767, k4=671, k5=463;
  151. #endif
  152.     int i;
  153.     int len=strlen(key);
  154.     for (i=0;i<len;i++) {
  155. #ifdef BUGGY_CODE_BW_COMPAT
  156.         /* This is the code as it was originally released.
  157.            It causes warnings on many systems and can generate
  158.            different results as well.  If you have files
  159.            encrypted using an older version you may want to
  160.            #define BUGGY_CODE_BW_COMPAT so as to be able to
  161.            decrypt them... */
  162.         k1 = (((k1<<3 | k1<<-13) + key[i]) & 65535);
  163.         k2 = (((k2<<3 | k2<<-13) ^ key[i]) & 65535);
  164.         k3 = (((k3<<3 | k3<<-13) - key[i]) & 65535);
  165.         k4 = ((key[i] - (k4<<3 | k4<<-13)) & 65535);
  166.         k5 = (((k5<<3 | k5<<-13) ^ ~key[i]) & 65535);
  167. #else
  168.         /* This code should be more portable */
  169.         k1 = (((k1<<3 | k1>>13) + key[i]) & 65535);
  170.         k2 = (((k2<<3 | k2>>13) ^ key[i]) & 65535);
  171.         k3 = (((k3<<3 | k3>>13) - key[i]) & 65535);
  172.         k4 = ((key[i] - (k4<<3 | k4>>13)) & 65535);
  173.         k5 = (((k5<<3 | k5>>13) ^ ~key[i]) & 65535);
  174. #endif
  175.     }
  176.     r->key[0] = (short)k1;
  177.     r->key[1] = (short)(k2|1);
  178.     r->key[2] = (short)k3;
  179.     r->key[3] = (short)k4;
  180.     r->key[4] = (short)k5;
  181.  
  182.     set_seed(r);
  183. }
  184.  
  185. /* These define the interface to a rotor object */
  186. static PyRotorObject *
  187. PyRotor_New(num_rotors, key)
  188.     int num_rotors;
  189.     char *key;
  190. {
  191.     PyRotorObject *xp;
  192.     xp = PyObject_NEW(PyRotorObject, &PyRotor_Type);
  193.     if (xp == NULL)
  194.         return NULL;
  195.     set_key(xp, key);
  196.  
  197.     xp->size = 256;
  198.     xp->size_mask = xp->size - 1;
  199.     xp->size_mask = 0;
  200.     xp->rotors = num_rotors;
  201.     xp->e_rotor = NULL;
  202.     xp->d_rotor = NULL;
  203.     xp->positions = NULL;
  204.     xp->advances = NULL;
  205.  
  206.     xp->e_rotor =
  207.          (unsigned char *)malloc((num_rotors * (xp->size * sizeof(char))));
  208.     if (xp->e_rotor == (unsigned char *)NULL)
  209.         goto fail;
  210.     xp->d_rotor =
  211.          (unsigned char *)malloc((num_rotors * (xp->size * sizeof(char))));
  212.     if (xp->d_rotor == (unsigned char *)NULL)
  213.         goto fail;
  214.     xp->positions = (unsigned char *)malloc(num_rotors * sizeof(char));
  215.     if (xp->positions == (unsigned char *)NULL)
  216.         goto fail;
  217.     xp->advances  = (unsigned char *)malloc(num_rotors * sizeof(char));
  218.     if (xp->advances == (unsigned char *)NULL)
  219.         goto fail;
  220.     return xp;
  221. fail:
  222.     Py_DECREF(xp);
  223.     return (PyRotorObject *)PyErr_NoMemory();
  224. }
  225.  
  226. /* These routines impliment the rotor itself */
  227.  
  228. /*  Here is a fairly sofisticated {en,de}cryption system.  It is bassed
  229. on the idea of a "rotor" machine.  A bunch of rotors, each with a
  230. different permutation of the alphabet, rotate around a different
  231. amount after encrypting one character.  The current state of the
  232. rotors is used to encrypt one character.
  233.  
  234.   The code is smart enought to tell if your alphabet has a number of
  235. characters equal to a power of two.  If it does, it uses logical
  236. operations, if not it uses div and mod (both require a division).
  237.  
  238.   You will need to make two changes to the code 1) convert to c, and
  239. customize for an alphabet of 255 chars 2) add a filter at the
  240. begining, and end, which subtracts one on the way in, and adds one on
  241. the way out.
  242.  
  243.   You might wish to do some timing studies.  Another viable
  244. alternative is to "byte stuff" the encrypted data of a normal (perhaps
  245. this one) encryption routine.
  246.  
  247. j'
  248. */
  249.  
  250. /*(defun RTR-make-id-rotor (rotor)
  251.   "Set ROTOR to the identity permutation"
  252.   (let ((j 0))
  253.     (while (< j RTR-size)
  254.       (aset rotor j j)
  255.       (setq j (+ 1 j)))
  256.     rotor))*/
  257. static void RTR_make_id_rotor(r, rtr)
  258.     PyRotorObject *r;
  259.     unsigned char *rtr;
  260. {
  261.     register int j;
  262.     register int size = r->size;
  263.     for (j=0;j<size;j++) {
  264.         rtr[j] = (unsigned char)j;
  265.     }
  266. }
  267.  
  268.  
  269. /*(defvar RTR-e-rotors 
  270.   (let ((rv (make-vector RTR-number-of-rotors 0))
  271.     (i 0)
  272.     tr)
  273.     (while (< i RTR-number-of-rotors)
  274.       (setq tr (make-vector RTR-size 0))
  275.       (RTR-make-id-rotor tr)
  276.       (aset rv i tr)
  277.       (setq i (+ 1 i)))
  278.     rv)
  279.   "The current set of encryption rotors")*/
  280. static void RTR_e_rotors(r)
  281.     PyRotorObject *r;
  282. {
  283.     int i;
  284.     for (i=0;i<r->rotors;i++) {
  285.         RTR_make_id_rotor(r,&(r->e_rotor[(i*r->size)]));
  286.     }
  287. }
  288.  
  289. /*(defvar RTR-d-rotors 
  290.   (let ((rv (make-vector RTR-number-of-rotors 0))
  291.     (i 0)
  292.     tr)
  293.     (while (< i RTR-number-of-rotors)
  294.       (setq tr (make-vector RTR-size 0))
  295.       (setq j 0)
  296.       (while (< j RTR-size)
  297.     (aset tr j j)
  298.     (setq j (+ 1 j)))
  299.       (aset rv i tr)
  300.       (setq i (+ 1 i)))
  301.     rv)
  302.   "The current set of decryption rotors")*/
  303. static void RTR_d_rotors(r)
  304.     PyRotorObject *r;
  305. {
  306.     register int i, j;
  307.     for (i=0;i<r->rotors;i++) {
  308.         for (j=0;j<r->size;j++) {
  309.             r->d_rotor[((i*r->size)+j)] = (unsigned char)j;
  310.         }
  311.     }
  312. }
  313.  
  314. /*(defvar RTR-positions (make-vector RTR-number-of-rotors 1)
  315.   "The positions of the rotors at this time")*/
  316. static void RTR_positions(r)
  317.     PyRotorObject *r;
  318. {
  319.     int i;
  320.     for (i=0;i<r->rotors;i++) {
  321.         r->positions[i] = 1;
  322.     }
  323. }
  324.  
  325. /*(defvar RTR-advances (make-vector RTR-number-of-rotors 1)
  326.   "The number of positions to advance the rotors at a time")*/
  327. static void RTR_advances(r) 
  328.     PyRotorObject *r;
  329. {
  330.     int i;
  331.     for (i=0;i<r->rotors;i++) {
  332.         r->advances[i] = 1;
  333.     }
  334. }
  335.  
  336. /*(defun RTR-permute-rotor (e d)
  337.   "Permute the E rotor, and make the D rotor its inverse"
  338.   ;; see Knuth for explaination of algorythm.
  339.   (RTR-make-id-rotor e)
  340.   (let ((i RTR-size)
  341.     q j)
  342.     (while (<= 2 i)
  343.       (setq q (fair16 i))        ; a little tricky, decrement here
  344.       (setq i (- i 1))            ; since we have origin 0 array's
  345.       (setq j (aref e q))
  346.       (aset e q (aref e i))
  347.       (aset e i j)
  348.       (aset d j i))
  349.     (aset e 0 (aref e 0))        ; don't forget e[0] and d[0]
  350.     (aset d (aref e 0) 0)))*/
  351. static void RTR_permute_rotor(r, e, d)
  352.     PyRotorObject *r;
  353.     unsigned char *e;
  354.     unsigned char *d;
  355. {
  356.     short i = r->size;
  357.     short q;
  358.     unsigned char j;
  359.     RTR_make_id_rotor(r,e);
  360.     while (2 <= i) {
  361.         q = r_rand(r,i);
  362.         i--;
  363.         j = e[q];
  364.         e[q] = (unsigned char)e[i];
  365.         e[i] = (unsigned char)j;
  366.         d[j] = (unsigned char)i;
  367.     }
  368.     e[0] = (unsigned char)e[0];
  369.     d[(e[0])] = (unsigned char)0;
  370. }
  371.  
  372. /*(defun RTR-init (key)
  373.   "Given KEY (a list of 5 16 bit numbers), initialize the rotor machine.
  374. Set the advancement, position, and permutation of the rotors"
  375.   (R16-set-state key)
  376.   (let (i)
  377.     (setq i 0)
  378.     (while (< i RTR-number-of-rotors)
  379.       (aset RTR-positions i (fair16 RTR-size))
  380.       (aset RTR-advances i (+ 1 (* 2 (fair16 (/ RTR-size 2)))))
  381.       (message "Initializing rotor %d..." i)
  382.       (RTR-permute-rotor (aref RTR-e-rotors i) (aref RTR-d-rotors i))
  383.       (setq i (+ 1 i)))))*/
  384. static void RTR_init(r)
  385.     PyRotorObject *r;
  386. {
  387.     int i;
  388.     set_seed(r);
  389.     RTR_positions(r);
  390.     RTR_advances(r);
  391.     RTR_e_rotors(r);
  392.     RTR_d_rotors(r);
  393.     for(i=0;i<r->rotors;i++) {
  394.         r->positions[i] = r_rand(r,r->size);
  395.         r->advances[i] = (1+(2*(r_rand(r,r->size/2))));
  396.         RTR_permute_rotor(r,&(r->e_rotor[(i*r->size)]),&(r->d_rotor[(i*r->size)]));
  397.     }
  398.     r->isinited = TRUE;
  399. }
  400.  
  401. /*(defun RTR-advance ()
  402.   "Change the RTR-positions vector, using the RTR-advances vector"
  403.   (let ((i 0)
  404.     (temp 0))
  405.     (if RTR-size-mask
  406.     (while (< i RTR-number-of-rotors)
  407.       (setq temp (+ (aref RTR-positions i) (aref RTR-advances i)))
  408.       (aset RTR-positions i (logand temp RTR-size-mask))
  409.       (if (and (>= temp RTR-size)
  410.            (< i (- RTR-number-of-rotors 1))) 
  411.           (aset RTR-positions (+ i 1)
  412.             (+ 1 (aref RTR-positions (+ i 1)))))
  413.       (setq i (+ i 1)))
  414.       (while (< i RTR-number-of-rotors)
  415.     (setq temp (+ (aref RTR-positions i) (aref RTR-advances i)))
  416.     (aset RTR-positions i (% temp RTR-size))
  417.     (if (and (>= temp RTR-size)
  418.          (< i (- RTR-number-of-rotors 1))) 
  419.         (aset RTR-positions (+ i 1)
  420.           (+ 1 (aref RTR-positions (+ i 1)))))
  421.     (setq i (+ i 1))))))*/
  422. static void RTR_advance(r)
  423.     PyRotorObject *r;
  424. {
  425.     register int i=0, temp=0;
  426.     if (r->size_mask) {
  427.         while (i<r->rotors) {
  428.             temp = r->positions[i] + r->advances[i];
  429.             r->positions[i] = temp & r->size_mask;
  430.             if ((temp >= r->size) && (i < (r->rotors - 1))) {
  431.                 r->positions[(i+1)] = 1 + r->positions[(i+1)];
  432.             }
  433.             i++;
  434.         }
  435.     } else {
  436.         while (i<r->rotors) {
  437.             temp = r->positions[i] + r->advances[i];
  438.             r->positions[i] = temp%r->size;
  439.             if ((temp >= r->size) && (i < (r->rotors - 1))) {
  440.                 r->positions[(i+1)] = 1 + r->positions[(i+1)];
  441.             }
  442.             i++;
  443.         }
  444.     }
  445. }
  446.  
  447. /*(defun RTR-e-char (p)
  448.   "Encrypt the character P with the current rotor machine"
  449.   (let ((i 0))
  450.     (if RTR-size-mask
  451.     (while (< i RTR-number-of-rotors)
  452.       (setq p (aref (aref RTR-e-rotors i)
  453.             (logand (logxor (aref RTR-positions i)
  454.                     p)
  455.                 RTR-size-mask)))
  456.       (setq i (+ 1 i)))
  457.       (while (< i RTR-number-of-rotors)
  458.       (setq p (aref (aref RTR-e-rotors i)
  459.             (% (logxor (aref RTR-positions i)
  460.                    p)
  461.                RTR-size)))
  462.     (setq i (+ 1 i))))
  463.     (RTR-advance)
  464.     p))*/
  465. static unsigned char RTR_e_char(r, p)
  466.     PyRotorObject *r;
  467.     unsigned char p;
  468. {
  469.     register int i=0;
  470.     register unsigned char tp=p;
  471.     if (r->size_mask) {
  472.         while (i < r->rotors) {
  473.             tp = r->e_rotor[(i*r->size)+(((r->positions[i] ^ tp) & r->size_mask))];
  474.             i++;
  475.         }
  476.     } else {
  477.         while (i < r->rotors) {
  478.             tp = r->e_rotor[(i*r->size)+(((r->positions[i] ^ tp) % (unsigned int) r->size))];
  479.             i++;
  480.         }
  481.     }
  482.     RTR_advance(r);
  483.     return ((unsigned char)tp);
  484. }
  485.  
  486. /*(defun RTR-d-char (c)
  487.   "Decrypt the character C with the current rotor machine"
  488.   (let ((i (- RTR-number-of-rotors 1)))
  489.     (if RTR-size-mask
  490.     (while (<= 0 i)
  491.       (setq c (logand (logxor (aref RTR-positions i)
  492.                   (aref (aref RTR-d-rotors i)
  493.                     c))
  494.               RTR-size-mask))
  495.       (setq i (- i 1)))
  496.     (while (<= 0 i)
  497.       (setq c (% (logxor (aref RTR-positions i)
  498.                  (aref (aref RTR-d-rotors i)
  499.                    c))
  500.              RTR-size))
  501.       (setq i (- i 1))))
  502.     (RTR-advance)
  503.     c))*/
  504. static unsigned char RTR_d_char(r, c)
  505.     PyRotorObject *r;
  506.     unsigned char c;
  507. {
  508.     register int i=r->rotors - 1;
  509.     register unsigned char tc=c;
  510.     if (r->size_mask) {
  511.         while (0 <= i) {
  512.             tc = (r->positions[i] ^ r->d_rotor[(i*r->size)+tc]) & r->size_mask;
  513.             i--;
  514.         }
  515.     } else {
  516.         while (0 <= i) {
  517.             tc = (r->positions[i] ^ r->d_rotor[(i*r->size)+tc]) % (unsigned int) r->size;
  518.             i--;
  519.         }
  520.     }
  521.     RTR_advance(r);
  522.     return(tc);
  523. }
  524.  
  525. /*(defun RTR-e-region (beg end key)
  526.   "Perform a rotor encryption of the region from BEG to END by KEY"
  527.   (save-excursion
  528.     (let ((tenth (/ (- end beg) 10)))
  529.       (RTR-init key)
  530.       (goto-char beg)
  531.       ;; ### make it stop evry 10% or so to tell us
  532.       (while (< (point) end)
  533.     (let ((fc (following-char)))
  534.       (insert-char (RTR-e-char fc) 1)
  535.       (delete-char 1))))))*/
  536. static void RTR_e_region(r, beg, len, doinit)
  537.     PyRotorObject *r;
  538.     unsigned char *beg;
  539.     int len;
  540.     int doinit;
  541. {
  542.     register int i;
  543.     if (doinit || r->isinited == FALSE)
  544.         RTR_init(r);
  545.     for (i=0;i<len;i++) {
  546.         beg[i]=RTR_e_char(r,beg[i]);
  547.     }
  548. }
  549.  
  550. /*(defun RTR-d-region (beg end key)
  551.   "Perform a rotor decryption of the region from BEG to END by KEY"
  552.   (save-excursion
  553.     (progn
  554.       (RTR-init key)
  555.       (goto-char beg)
  556.       (while (< (point) end)
  557.     (let ((fc (following-char)))
  558.       (insert-char (RTR-d-char fc) 1)
  559.       (delete-char 1))))))*/
  560. static void RTR_d_region(r, beg, len, doinit)
  561.     PyRotorObject *r;
  562.     unsigned char *beg;
  563.     int len;
  564.     int doinit;
  565. {
  566.     register int i;
  567.     if (doinit || r->isinited == FALSE)
  568.         RTR_init(r);
  569.     for (i=0;i<len;i++) {
  570.         beg[i]=RTR_d_char(r,beg[i]);
  571.     }
  572. }
  573.  
  574.  
  575. /*(defun RTR-key-string-to-ints (key)
  576.   "Convert a string into a list of 4 numbers"
  577.   (let ((k1 995)
  578.     (k2 576)
  579.     (k3 767)
  580.     (k4 671)
  581.     (k5 463)
  582.     (i 0))
  583.     (while (< i (length key))
  584.       (setq k1 (logand (+      (logior (lsh k1 3) (lsh k1 -13)) (aref key i)) 65535))
  585.       (setq k2 (logand (logxor (logior (lsh k2 3) (lsh k2 -13)) (aref key i)) 65535))
  586.       (setq k3 (logand (-      (logior (lsh k3 3) (lsh k3 -13)) (aref key i)) 65535))
  587.       (setq k4 (logand (-      (aref key i) (logior (lsh k4 3) (lsh k4 -13))) 65535))
  588.       (setq k5 (logand (logxor (logior (lsh k5 3) (lsh k5 -13)) (lognot (aref key i))) 65535))
  589.       (setq i (+ i 1)))
  590.     (list k1 (logior 1 k2) k3 k4 k5)))*/
  591. /* This is done in set_key() above */
  592.  
  593. #if 0
  594. /*(defun encrypt-region (beg end key)
  595.   "Interactivly encrypt the region"
  596.   (interactive "r\nsKey:")
  597.   (RTR-e-region beg end (RTR-key-string-to-ints key)))*/
  598. static void encrypt_region(r, region, len)
  599.     PyRotorObject *r;
  600.     unsigned char *region;
  601.     int len;
  602. {
  603.     RTR_e_region(r,region,len,TRUE);
  604. }
  605.  
  606. /*(defun decrypt-region (beg end key)
  607.   "Interactivly decrypt the region"
  608.   (interactive "r\nsKey:")
  609.   (RTR-d-region beg end (RTR-key-string-to-ints key)))*/
  610. static void decrypt_region(r, region, len)
  611.     PyRotorObject *r;
  612.     unsigned char *region;
  613.     int len;
  614. {
  615.     RTR_d_region(r,region,len,TRUE);
  616. }
  617. #endif
  618.  
  619. /* Rotor methods */
  620.  
  621. static void
  622. PyRotor_Dealloc(xp)
  623.     PyRotorObject *xp;
  624. {
  625.     PyMem_XDEL(xp->e_rotor);
  626.     PyMem_XDEL(xp->d_rotor);
  627.     PyMem_XDEL(xp->positions);
  628.     PyMem_XDEL(xp->advances);
  629.     PyMem_DEL(xp);
  630. }
  631.  
  632. static PyObject * 
  633. PyRotor_Encrypt(self, args)
  634.     PyRotorObject *self;
  635.     PyObject * args;
  636. {
  637.     char *string = (char *)NULL;
  638.     int len = 0;
  639.     PyObject * rtn = (PyObject * )NULL;
  640.     char *tmp;
  641.  
  642.     if (!PyArg_Parse(args,"s#",&string, &len))
  643.         return NULL;
  644.     if (!(tmp = (char *)malloc(len+5))) {
  645.         PyErr_NoMemory();
  646.         return NULL;
  647.     }
  648.     memset(tmp,'\0',len+1);
  649.     memcpy(tmp,string,len);
  650.     RTR_e_region(self,(unsigned char *)tmp,len, TRUE);
  651.     rtn = PyString_FromStringAndSize(tmp,len);
  652.     free(tmp);
  653.     return(rtn);
  654. }
  655.  
  656. static PyObject * 
  657. PyRotor_EncryptMore(self, args)
  658.     PyRotorObject *self;
  659.     PyObject * args;
  660. {
  661.     char *string = (char *)NULL;
  662.     int len = 0;
  663.     PyObject * rtn = (PyObject * )NULL;
  664.     char *tmp;
  665.  
  666.     if (!PyArg_Parse(args,"s#",&string, &len))
  667.         return NULL;
  668.     if (!(tmp = (char *)malloc(len+5))) {
  669.         PyErr_NoMemory();
  670.         return NULL;
  671.     }
  672.     memset(tmp,'\0',len+1);
  673.     memcpy(tmp,string,len);
  674.     RTR_e_region(self,(unsigned char *)tmp,len, FALSE);
  675.     rtn = PyString_FromStringAndSize(tmp,len);
  676.     free(tmp);
  677.     return(rtn);
  678. }
  679.  
  680. static PyObject * 
  681. PyRotor_Decrypt(self, args)
  682.     PyRotorObject *self;
  683.     PyObject * args;
  684. {
  685.     char *string = (char *)NULL;
  686.     int len = 0;
  687.     PyObject * rtn = (PyObject * )NULL;
  688.     char *tmp;
  689.  
  690.     if (!PyArg_Parse(args,"s#",&string, &len))
  691.         return NULL;
  692.     if (!(tmp = (char *)malloc(len+5))) {
  693.         PyErr_NoMemory();
  694.         return NULL;
  695.     }
  696.     memset(tmp,'\0',len+1);
  697.     memcpy(tmp,string,len);
  698.     RTR_d_region(self,(unsigned char *)tmp,len, TRUE);
  699.     rtn = PyString_FromStringAndSize(tmp,len);
  700.     free(tmp);
  701.     return(rtn);
  702. }
  703.  
  704. static PyObject * 
  705. PyRotor_DecryptMore(self, args)
  706.     PyRotorObject *self;
  707.     PyObject * args;
  708. {
  709.     char *string = (char *)NULL;
  710.     int len = 0;
  711.     PyObject * rtn = (PyObject * )NULL;
  712.     char *tmp;
  713.  
  714.     if (!PyArg_Parse(args,"s#",&string, &len))
  715.         return NULL;
  716.     if (!(tmp = (char *)malloc(len+5))) {
  717.         PyErr_NoMemory();
  718.         return NULL;
  719.     }
  720.     memset(tmp,'\0',len+1);
  721.     memcpy(tmp,string,len);
  722.     RTR_d_region(self,(unsigned char *)tmp,len, FALSE);
  723.     rtn = PyString_FromStringAndSize(tmp,len);
  724.     free(tmp);
  725.     return(rtn);
  726. }
  727.  
  728. static PyObject * 
  729. PyRotor_SetKey(self, args)
  730.     PyRotorObject *self;
  731.     PyObject * args;
  732. {
  733.     char *string;
  734.  
  735.     if (PyArg_Parse(args,"s",&string))
  736.         set_key(self,string);
  737.     Py_INCREF(Py_None);
  738.     return Py_None;
  739. }
  740.  
  741. static struct PyMethodDef PyRotor_Methods[] = {
  742.     {"encrypt",    (PyCFunction)PyRotor_Encrypt},
  743.     {"encryptmore",    (PyCFunction)PyRotor_EncryptMore},
  744.     {"decrypt",    (PyCFunction)PyRotor_Decrypt},
  745.     {"decryptmore",    (PyCFunction)PyRotor_DecryptMore},
  746.     {"setkey",    (PyCFunction)PyRotor_SetKey},
  747.     {NULL,        NULL}        /* sentinel */
  748. };
  749.  
  750.  
  751. /* Return a rotor object's named attribute. */
  752. static PyObject * 
  753. PyRotor_GetAttr(s, name)
  754.     PyRotorObject *s;
  755.     char *name;
  756. {
  757.     return Py_FindMethod(PyRotor_Methods, (PyObject * ) s, name);
  758. }
  759.  
  760. statichere PyTypeObject PyRotor_Type = {
  761.     PyObject_HEAD_INIT(&PyType_Type)
  762.     0,                /*ob_size*/
  763.     "rotor",            /*tp_name*/
  764.     sizeof(PyRotorObject),        /*tp_size*/
  765.     0,                /*tp_itemsize*/
  766.     /* methods */
  767.     (destructor)PyRotor_Dealloc,    /*tp_dealloc*/
  768.     0,                /*tp_print*/
  769.     (getattrfunc)PyRotor_GetAttr,    /*tp_getattr*/
  770.     0,                /*tp_setattr*/
  771.     0,                /*tp_compare*/
  772.     0,                /*tp_repr*/
  773.     0,                              /*tp_hash*/
  774. };
  775.  
  776.  
  777. static PyObject * 
  778. PyRotor_Rotor(self, args)
  779.     PyObject * self;
  780.     PyObject * args;
  781. {
  782.     char *string;
  783.     PyRotorObject *r;
  784.     int len;
  785.     int num_rotors;
  786.  
  787.     if (PyArg_Parse(args,"s#", &string, &len)) {
  788.         num_rotors = 6;
  789.     } else {
  790.         PyErr_Clear();
  791.         if (!PyArg_Parse(args,"(s#i)", &string, &len, &num_rotors))
  792.             return NULL;
  793.     }
  794.     r = PyRotor_New(num_rotors, string);
  795.     return (PyObject * )r;
  796. }
  797.  
  798. static struct PyMethodDef PyRotor_Rotor_Methods[] = {
  799.     {"newrotor",        (PyCFunction)PyRotor_Rotor},
  800.     {NULL,            NULL}         /* Sentinel */
  801. };
  802.  
  803.  
  804. /* Initialize this module.
  805.    This is called when the first 'import rotor' is done,
  806.    via a table in config.c, if config.c is compiled with USE_ROTOR
  807.    defined. */
  808.  
  809. void
  810. initrotor()
  811. {
  812.     PyObject * m;
  813.  
  814.     m = Py_InitModule("rotor", PyRotor_Rotor_Methods);
  815. }
  816.